lst = [1, "s", True]
lst
[1, 's', True]
id(lst)
2187405640832
id(lst[0])
2187323703536
id(lst[1])
2187324525680
# !pip install numpy
import numpy as np
lst = [1, 2, 3, 4, 5]
lst
[1, 2, 3, 4, 5]
arr = np.array([1, 2, 3, 4, 5])
arr
array([1, 2, 3, 4, 5])
type(arr)
numpy.ndarray
arr.dtype
dtype('int32')
arr = np.array(lst, dtype=np.float16)
arr
array([1., 2., 3., 4., 5.], dtype=float16)
arr = np.array(lst)
arr.dtype
dtype('int32')
arr.astype(np.float32)
array([1., 2., 3., 4., 5.], dtype=float32)
arr_new = arr.astype(np.float32)
arr_new.dtype
dtype('float32')
arr.dtype
dtype('int32')
for i in lst:
print(i)
1 2 3 4 5
for i in arr:
print(i)
1 2 3 4 5
lst = [7, 2, 9, 10]
arr = np.array([7, 2, 9, 10])
arr
array([ 7, 2, 9, 10])
arr.shape
(4,)
arr.ndim
1
lst = [
[7, 2, 9, 10]
]
arr = np.array(lst)
arr
array([[ 7, 2, 9, 10]])
arr.ndim
2
arr.shape
(1, 4)
lst = [[[7, 2, 9, 10]]]
arr = np.array(lst)
print(arr)
print(arr.shape)
print(arr.ndim)
[[[ 7 2 9 10]]] (1, 1, 4) 3
lst = [[[[7], [2], [9], [10]]]]
arr = np.array(lst)
print(arr)
print(arr.shape)
print(arr.ndim)
[[[[ 7] [ 2] [ 9] [10]]]] (1, 1, 4, 1) 4
lst = [
[5, 3, 4],
[9, 0, 1]
]
arr = np.array( [
[5, 3, 4],
[9, 0, 1]
])
arr
array([[5, 3, 4],
[9, 0, 1]])
arr.shape
(2, 3)
arr.ndim
2
lst = [
[[5, 3, 4], [9, 1, 3]],
[[5, 3, 4], [9, 1, 3]],
[[5, 3, 4], [9, 1, 3]],
[[5, 3, 4], [9, 1, 3]]
]
arr = np.array(lst)
print(arr.shape)
arr
(4, 2, 3)
array([[[5, 3, 4],
[9, 1, 3]],
[[5, 3, 4],
[9, 1, 3]],
[[5, 3, 4],
[9, 1, 3]],
[[5, 3, 4],
[9, 1, 3]]])
# arr[0, :, :]
arr[0, 0]
array([5, 3, 4])
arr[0].shape
(2, 3)
arr[:2, :, :]
array([[[5, 3, 4],
[9, 1, 3]],
[[5, 3, 4],
[9, 1, 3]]])
arr[:, :, 1]
array([[3, 1],
[3, 1],
[3, 1],
[3, 1]])
arr[0][0][0]
5
arr[0,0,0]
5
lst = [1, 2, 3, 4, 5]
lst
[1, 2, 3, 4, 5]
lst.append(10)
lst
[1, 2, 3, 4, 5, 10]
arr = np.array([1, 2, 3, 4, 5])
arr = np.append(arr, [10]) # It flattens then appends
arr
array([ 1, 2, 3, 4, 5, 10])
arr = np.arange(24).reshape(2, 3, 4)
print(arr)
arr.shape
[[[ 0 1 2 3] [ 4 5 6 7] [ 8 9 10 11]] [[12 13 14 15] [16 17 18 19] [20 21 22 23]]]
(2, 3, 4)
arr = np.append(arr, [10])
arr
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 10])
# arr.flatten()
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
list(range(24))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
np.array(list(range(24)))
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
np.arange(24)
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
np.array([0, 1, 2, 3, 4, 5, 6, , , 23])
arr = np.arange(24)
arr
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
arr.shape
(24,)
arr.reshape(1, 24)
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23]])
arr.reshape(1, 1, 24)
array([[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23]]])
arr.reshape(6, 4)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]])
arr.reshape(6, 4, 1)
array([[[ 0],
[ 1],
[ 2],
[ 3]],
[[ 4],
[ 5],
[ 6],
[ 7]],
[[ 8],
[ 9],
[10],
[11]],
[[12],
[13],
[14],
[15]],
[[16],
[17],
[18],
[19]],
[[20],
[21],
[22],
[23]]])
arr.reshape(3, 8)
array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15],
[16, 17, 18, 19, 20, 21, 22, 23]])
arr.reshape(1, 3, 8)
array([[[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15],
[16, 17, 18, 19, 20, 21, 22, 23]]])
arr.reshape(5, 8)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Cell In[116], line 1 ----> 1 arr.reshape(5, 8) ValueError: cannot reshape array of size 24 into shape (5,8)
arr.reshape(-1, 8)
array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15],
[16, 17, 18, 19, 20, 21, 22, 23]])
arr.reshape(3, -1, 2)
array([[[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7]],
[[ 8, 9],
[10, 11],
[12, 13],
[14, 15]],
[[16, 17],
[18, 19],
[20, 21],
[22, 23]]])
arr = arr.reshape(3, -1, 2)
arr.shape
(3, 4, 2)
arr
array([[[ 0, 1],
[ 2, 3],
[ 4, 5],
[ 6, 7]],
[[ 8, 9],
[10, 11],
[12, 13],
[14, 15]],
[[16, 17],
[18, 19],
[20, 21],
[22, 23]]])
arr.reshape(-1)
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
arr.reshape(-1, 24)
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23]])
lst1 = [1, 2, 3, 4, 5]
arr1 = np.array(lst1)
arr1
array([1, 2, 3, 4, 5])
lst2 = [10, 20, 30, 40, 50]
arr2 = np.array(lst2)
arr2
array([10, 20, 30, 40, 50])
# Vectorization
arr1 + arr2
array([11, 22, 33, 44, 55])
res = []
for x,y in zip(arr1, arr2):
res.append(x+y)
np.array(res)
array([11, 22, 33, 44, 55])
arr1
array([1, 2, 3, 4, 5])
arr1 + 50
array([51, 52, 53, 54, 55])
arr1 * 50
array([ 50, 100, 150, 200, 250])
arr1 / 50
array([0.02, 0.04, 0.06, 0.08, 0.1 ])
arr1 // 50
array([0, 0, 0, 0, 0], dtype=int32)
arr1 ** 2
array([ 1, 4, 9, 16, 25])
arr1 ** 0.5
array([1. , 1.41421356, 1.73205081, 2. , 2.23606798])
np.power(arr1, 2) # arr1**2
array([ 1, 4, 9, 16, 25], dtype=int32)
np.sqrt(arr1) # arr1**0.5
array([1. , 1.41421356, 1.73205081, 2. , 2.23606798])
np.log(arr1)
array([0. , 0.69314718, 1.09861229, 1.38629436, 1.60943791])
np.exp(arr1)
array([ 2.71828183, 7.3890561 , 20.08553692, 54.59815003,
148.4131591 ])
np.sin(arr1)
array([ 0.84147098, 0.90929743, 0.14112001, -0.7568025 , -0.95892427])
np.deg2rad([90, 180])
array([1.57079633, 3.14159265])
np.pi
3.141592653589793
arr = np.arange(24).reshape(2, 3, 4)
arr
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
arr.shape
(2, 3, 4)
len(arr.shape) # arr.ndim
3
arr.ndim
3
arr.size
24
arr.dtype
dtype('int32')
arr.astype('float32')
array([[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.]],
[[12., 13., 14., 15.],
[16., 17., 18., 19.],
[20., 21., 22., 23.]]], dtype=float32)
arr = np.array([1, 2, 30])
arr.shape
(3,)
len(arr.shape)
1
arr.size
3
arr = np.arange(24)
arr
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
arr = arr.reshape(3, 8)
arr
array([[ 0, 1, 2, 3, 4, 5, 6, 7],
[ 8, 9, 10, 11, 12, 13, 14, 15],
[16, 17, 18, 19, 20, 21, 22, 23]])
arr.reshape(-1)
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
arr.reshape(24)
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
arr = arr.reshape(3, 8, 1, 1)
arr.ravel()
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
arr.flatten()
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23])
x = 8
y = 8
print(id(x))
print(id(y))
2187323703760 2187323703760
y = 20
print(id(x))
print(id(y))
2187323703760 2187323704144
lst1 = [1, 2, 3]
lst2 = lst1
print(id(lst1))
print(id(lst2))
2187799746048 2187799746048
# Reference Equality
lst1 is lst2
True
lst1[0] = 50
print(lst1)
print(lst2)
[50, 2, 3] [50, 2, 3]
lst2 = [3, 3, 3, 3]
lst1[0] = 100
print(lst1)
print(lst2)
[100, 2, 3] [3, 3, 3, 3]
lst2[0] = 70
lst2
[70, 3, 3, 3]
x = 5
y = 5
x == y
True
x = 100
x == y
False
View vs deep-Copy¶arr1 = np.random.randn(2, 3)
arr2 = arr1
# Referenece Equality
print(id(arr1))
print(id(arr2))
arr2 is arr1
2187827405488 2187827405488
True
print(arr1)
[[-0.07320952 0.26433901 -1.3630782 ] [ 1.97975398 0.01702801 0.35591298]]
arr1[0] = 5
arr2
array([[5. , 5. , 5. ],
[1.97975398, 0.01702801, 0.35591298]])
arr = np.random.randint(0, 100, size=(2, 3))
arr
array([[74, 69, 25],
[86, 3, 7]])
arr_view = arr.view().reshape(-1)
arr_view
array([74, 69, 25, 86, 3, 7])
arr_view[0] = 555
arr_view
array([555, 69, 25, 86, 3, 7])
arr
array([[555, 69, 25],
[ 86, 3, 7]])
arr_deep = np.copy(arr)
arr_deep
array([[555, 69, 25],
[ 86, 3, 7]])
print(id(arr))
print(id(arr_deep))
2187827400400 2187827400304
arr[0] = 9999
arr
array([[9999, 9999, 9999],
[ 86, 3, 7]])
arr_deep
array([[555, 69, 25],
[ 86, 3, 7]])
arr = np.arange(10).reshape(-1, 2, 1, 5)
arr
array([[[[0, 1, 2, 3, 4]],
[[5, 6, 7, 8, 9]]]])
arr.shape
(1, 2, 1, 5)
arr.squeeze()
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
arr.squeeze().shape
(2, 5)
arr = np.arange(10)
arr
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
a = np.expand_dims(arr, axis=0)
a.shape
(1, 10)
# np.array([img])
# B x H x W x D
# (1, 100, 100, 3)
np.array([[1, 2, 3]]).shape
(1, 3)
arr = np.array([1, 2, 3])
arr.shape
(3,)
np.expand_dims(arr, axis=0).shape
(1, 3)
np.array([arr]).shape
(1, 3)
np.arange(4, 10.01, 2)
array([ 4., 6., 8., 10.])
np.zeros(shape=(3,4))
array([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
img = np.zeros(shape=(100,100,3))
img[:, :, 0] = 1
img
array([[[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.],
...,
[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.]],
[[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.],
...,
[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.]],
[[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.],
...,
[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.]],
...,
[[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.],
...,
[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.]],
[[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.],
...,
[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.]],
[[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.],
...,
[1., 0., 0.],
[1., 0., 0.],
[1., 0., 0.]]])
img = np.zeros(shape=(100,100,3))
img
array([[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
...,
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]],
[[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.],
...,
[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]]])
import matplotlib.pyplot as plt
img + 0.5
array([[[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
...,
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5]],
[[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
...,
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5]],
[[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
...,
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5]],
...,
[[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
...,
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5]],
[[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
...,
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5]],
[[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
...,
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5],
[0.5, 0.5, 0.5]]])
plt.imshow(img + 0.5)
<matplotlib.image.AxesImage at 0x1fd68b32b00>
img[:, :, 0] = 1
img = np.zeros(shape=(100,100,3))
# img[:, :, 0] = 1
img[:, :, 1] = 1
img[:, :, 2] = 1
plt.imshow(img)
<matplotlib.image.AxesImage at 0x1fd68c44d00>
arr = np.ones(shape=[100, 100])
arr
array([[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
...,
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.]])
np.zeros(arr.shape)
array([[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
...,
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.]])
np.zeros_like(arr)
array([[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
...,
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.],
[0., 0., 0., ..., 0., 0., 0.]])
np.ones_like(arr)
array([[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
...,
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.],
[1., 1., 1., ..., 1., 1., 1.]])
np.ones(shape=[100, 100]) * 50
array([[50., 50., 50., ..., 50., 50., 50.],
[50., 50., 50., ..., 50., 50., 50.],
[50., 50., 50., ..., 50., 50., 50.],
...,
[50., 50., 50., ..., 50., 50., 50.],
[50., 50., 50., ..., 50., 50., 50.],
[50., 50., 50., ..., 50., 50., 50.]])
np.eye(5)
array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
np.eye(5, 8)
array([[1., 0., 0., 0., 0., 0., 0., 0.],
[0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 1., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 0., 0., 0.]])
np.arange(0, 10, 1)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.linspace(0, 9, 10)
array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
np.linspace(0, 1, 11)
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
np.arange(0, 1.05, 0.1)
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
# Return random floats in the half-open interval [0.0, 1.0)
np.random.random()
0.5008153452935044
np.random.random(size=(3, 4))
array([[0.64925109, 0.58245294, 0.97262966, 0.78429056],
[0.2209591 , 0.55783465, 0.1886229 , 0.8964357 ],
[0.52853941, 0.65390786, 0.30126855, 0.35649155]])
np.random.rand(3, 4)
array([[0.74224086, 0.23283405, 0.52820927, 0.09909223],
[0.35562799, 0.07113241, 0.49367314, 0.23931673],
[0.27010681, 0.14673219, 0.07633481, 0.48630191]])
# from `low` (inclusive) to `high` (exclusive).
np.random.randint(0, 10)
7
np.random.randint(0, 10, (3, 4))
array([[7, 8, 0, 7],
[2, 4, 9, 9],
[0, 2, 4, 1]])
# Return a sample (or samples) from the "standard normal" distribution.
np.random.randn(3, 4)
array([[-0.03770591, 2.63111902, -1.21322968, 0.17210536],
[ 0.087345 , -0.49916868, 0.59380472, -0.14034652],
[ 1.23123313, 1.00723379, 0.55213194, -1.32125358]])
# Pseudo-random
np.random.seed(1)
np.random.randn(3, 4)
array([[ 1.62434536, -0.61175641, -0.52817175, -1.07296862],
[ 0.86540763, -2.3015387 , 1.74481176, -0.7612069 ],
[ 0.3190391 , -0.24937038, 1.46210794, -2.06014071]])
np.random.randn(3, 4)
array([[ 0.79103195, -0.90938745, 1.40279431, -1.40185106],
[ 0.58685709, 2.19045563, -0.99053633, -0.56629773],
[ 0.09965137, -0.50347565, -1.55066343, 0.06856297]])
arr = np.random.random((8, 3))
arr
array([[0.14038694, 0.19810149, 0.80074457],
[0.96826158, 0.31342418, 0.69232262],
[0.87638915, 0.89460666, 0.08504421],
[0.03905478, 0.16983042, 0.8781425 ],
[0.09834683, 0.42110763, 0.95788953],
[0.53316528, 0.69187711, 0.31551563],
[0.68650093, 0.83462567, 0.01828828],
[0.75014431, 0.98886109, 0.74816565]])
arr.mean()
0.5458665438905308
arr.mean(axis=0)
array([0.51153123, 0.56405428, 0.56201412])
arr.mean(axis=1)
array([0.37974433, 0.65800279, 0.61868001, 0.36234257, 0.492448 ,
0.51351934, 0.51313829, 0.82905702])
np.mean(arr, axis=1)
array([0.37974433, 0.65800279, 0.61868001, 0.36234257, 0.492448 ,
0.51351934, 0.51313829, 0.82905702])
np.max()
np.median(arr, axis=1)
array([0.19810149, 0.69232262, 0.87638915, 0.16983042, 0.42110763,
0.53316528, 0.68650093, 0.75014431])
arr.median
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) Cell In[705], line 1 ----> 1 arr.median AttributeError: 'numpy.ndarray' object has no attribute 'median'
arr.max()
0.9888610889064947
arr.max(axis=0)
array([0.96826158, 0.98886109, 0.95788953])
arr.max(axis=1)
array([0.80074457, 0.96826158, 0.89460666, 0.8781425 , 0.95788953,
0.69187711, 0.83462567, 0.98886109])
arr.min(axis=1)
array([0.14038694, 0.31342418, 0.08504421, 0.03905478, 0.09834683,
0.31551563, 0.01828828, 0.74816565])
arr.std(axis=0)
array([0.34667095, 0.30656491, 0.34445228])
arr.var(axis=0)
array([0.12018075, 0.09398204, 0.11864738])
arr.std(axis=0)**2
array([0.12018075, 0.09398204, 0.11864738])
arr = np.array([5, 6, 1, 3, 2, 4])
arr
array([5, 6, 1, 3, 2, 4])
np.sort(arr)
array([1, 2, 3, 4, 5, 6])
# Inplace Sorting
arr.sort()
arr
array([1, 2, 3, 4, 5, 6])
arr = np.array([5, 6, 1, 3, 2, 4])*10
arr
array([50, 60, 10, 30, 20, 40])
idx = np.argsort(arr)
idx
array([2, 4, 3, 5, 0, 1], dtype=int64)
arr[idx]
array([10, 20, 30, 40, 50, 60])
arr[[0, 1, 3]]
array([50, 60, 30])
np.max(arr)
60
np.argmax(arr)
1
arr = np.arange(12).reshape(3, 4)
arr
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
arr[0, 0]
0
arr[1, 1]
5
arr[(0, 1), (0, 1)]
array([0, 5])
arr[(0, 1), (0, 1)] = 100
arr
array([[100, 1, 2, 3],
[ 4, 100, 6, 7],
[ 8, 9, 10, 11]])
arr[1][2]
6
# The same
arr[1,2]
6
arr[:, :]
array([[100, 1, 2, 3],
[ 4, 100, 6, 7],
[ 8, 9, 10, 11]])
# The same
arr
array([[100, 1, 2, 3],
[ 4, 100, 6, 7],
[ 8, 9, 10, 11]])
arr[0, :] # 1st row
arr[0]
array([100, 1, 2, 3])
arr[:, 0] # 1st col
array([100, 4, 8])
arr[:, 3]
arr[:, -1]
array([ 3, 7, 11])
arr[0:2, 0:2]
arr[:2, :2]
array([[100, 1],
[ 4, 100]])
arr = np.arange(13)
arr
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
arr[::2]
array([ 0, 2, 4, 6, 8, 10, 12])
mask = arr % 2 == 0
mask
array([ True, False, True, False, True, False, True, False, True,
False, True, False, True])
arr.shape
(13,)
mask.shape
(13,)
arr[mask]
array([ 0, 2, 4, 6, 8, 10, 12])
arr[arr%2==0]
array([ 0, 2, 4, 6, 8, 10, 12])
arr[arr%2!=0]
array([ 1, 3, 5, 7, 9, 11])
mask.dtype
dtype('bool')
mask.shape
(13,)
mask
array([ True, False, True, False, True, False, True, False, True,
False, True, False, True])
np.count_nonzero(mask)
7
np.sum(mask)
7
mask.astype('int')
array([1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1])

mat_1 = np.array(range(10, 14))
mat_1 = np.reshape(mat_1, (2, 2))
mat_1
array([[10, 11],
[12, 13]])
mat_2 = np.array(range(30, 34))
mat_2 = np.reshape(mat_2, (2, 2))
mat_2
array([[30, 31],
[32, 33]])
mat_1 + mat_2
array([[40, 42],
[44, 46]])
mat_1 - mat_2
array([[-20, -20],
[-20, -20]])
mat_1 * mat_2 # elementwise multiplication
array([[300, 341],
[384, 429]])
mat_1 / mat_2
array([[0.33333333, 0.35483871],
[0.375 , 0.39393939]])
mat_1 % mat_2
array([[10, 11],
[12, 13]])

5 * mat_1
array([[50, 55],
[60, 65]])

mat_1 = np.array([[2, 4], [7, 8], [3, 2]])
mat_1
array([[2, 4],
[7, 8],
[3, 2]])
mat_2 = np.array([[1, 3], [4, 7]])
mat_2
array([[1, 3],
[4, 7]])
np.dot(mat_1, mat_2) # 3x2
array([[18, 34],
[39, 77],
[11, 23]])
mat_1.dot(mat_2) # 3x2
array([[18, 34],
[39, 77],
[11, 23]])
mat_1 @ mat_2 # 3x2
array([[18, 34],
[39, 77],
[11, 23]])
np.matmul(mat_1, mat_2)
array([[18, 34],
[39, 77],
[11, 23]])
mat_1 * mat_2 # Element wise Multiplication
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Cell In[814], line 1 ----> 1 mat_1 * mat_2 ValueError: operands could not be broadcast together with shapes (3,2) (2,2)

mat_1
array([[2, 4],
[7, 8],
[3, 2]])
mat_1.T
array([[2, 7, 3],
[4, 8, 2]])
mat_1.transpose()
array([[2, 7, 3],
[4, 8, 2]])
vec_1 = np.array([1, 2])
vec_2 = np.array([3, 4])
print(vec_1.shape)
print(vec_2.shape)
vec_1 @ vec_2
(2,) (2,)
11
vec_1 = np.array([[1, 2]]) # row
vec_2 = np.array([[3], [4]]) # col
print(vec_1.shape)
print(vec_2.shape)
vec_1 @ vec_2
(1, 2) (2, 1)
array([[11]])
vec_1 = np.array([[1, 2]]) # row
vec_2 = np.array([[3, 4]]) # row
print(vec_1.shape)
print(vec_2.shape)
vec_1 @ vec_2
(1, 2) (1, 2)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Cell In[826], line 7 4 print(vec_1.shape) 5 print(vec_2.shape) ----> 7 vec_1 @ vec_2 ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 1 is different from 2)
vec_1 = np.array([[1, 2]]) # row
vec_2 = np.array([[3, 4]]) # row
print(vec_1.shape)
print(vec_2.shape)
vec_1 @ vec_2.T
(1, 2) (1, 2)
array([[11]])
x = np.linspace(-3, 3, 5)
y = np.linspace(-3, 3, 5)
xx, yy = np.meshgrid(x, y)
plt.scatter(xx, yy)

x = np.linspace(-3, 3, 5)
y = np.linspace(-3, 3, 5)
print(x)
print(y)
[-3. -1.5 0. 1.5 3. ] [-3. -1.5 0. 1.5 3. ]
plt.scatter(x, y)
<matplotlib.collections.PathCollection at 0x1fd690e5d80>
xx, yy = np.meshgrid(x, y)
print(xx)
print('-'*30)
print(yy)
[[-3. -1.5 0. 1.5 3. ] [-3. -1.5 0. 1.5 3. ] [-3. -1.5 0. 1.5 3. ] [-3. -1.5 0. 1.5 3. ] [-3. -1.5 0. 1.5 3. ]] ------------------------------ [[-3. -3. -3. -3. -3. ] [-1.5 -1.5 -1.5 -1.5 -1.5] [ 0. 0. 0. 0. 0. ] [ 1.5 1.5 1.5 1.5 1.5] [ 3. 3. 3. 3. 3. ]]
plt.scatter(xx, yy);

arr_1 = np.array([[0, 2], [7, 6]])
arr_2 = np.array([[3, 7], [1, 4]])
np.vstack([arr_1, arr_2])
array([[0, 2],
[7, 6],
[3, 7],
[1, 4]])
np.hstack([arr_1, arr_2])
array([[0, 2, 3, 7],
[7, 6, 1, 4]])
# Scalar
np.array(1000).shape
()
a = np.array([1, 2])
b = np.array([3, 4])
# np.sum(a * b)
print(a.dot(b))
print(np.dot(a, b))
11 11
result = 0
for i in range(len(a)):
result += a[i] * b[i]
result
11
# Vectorization
a @ b
11
# using For-loop
def slow_dot_product(a, b):
result = 0
for i in range(len(a)):
result += a[i] * b[i]
return result
slow_dot_product(a, b)
11
import time
a = np.random.randn(10000)
b = np.random.randn(10000)
tic = time.process_time()
for _ in range(10000):
slow_dot_product(a, b)
toc = time.process_time()
dt1 = toc - tic
print("Time in sec:", dt1)
Time in sec: 28.625
tic = time.process_time()
for _ in range(10000):
a @ b
toc = time.process_time()
dt1 = toc - tic
print("Time in sec:", dt1)
Time in sec: 0.03125
28.625 / 0.03125
916.0
arr = np.array([3, 4])
np.linalg.norm(arr)
5.0
np.sqrt(arr.dot(arr))
5.0
arr = np.array([1, 2, 3, 4])
arr
array([1, 2, 3, 4])
arr.T
array([1, 2, 3, 4])
arr.dot(arr)
30
arr = np.arange(9).reshape(3, 3)
arr
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
np.linalg.det(arr)
0.0
np.linalg.inv(arr)
--------------------------------------------------------------------------- LinAlgError Traceback (most recent call last) Cell In[876], line 1 ----> 1 np.linalg.inv(arr) File <__array_function__ internals>:180, in inv(*args, **kwargs) File ~\anaconda3\lib\site-packages\numpy\linalg\linalg.py:552, in inv(a) 550 signature = 'D->D' if isComplexType(t) else 'd->d' 551 extobj = get_linalg_error_extobj(_raise_linalgerror_singular) --> 552 ainv = _umath_linalg.inv(a, signature=signature, extobj=extobj) 553 return wrap(ainv.astype(result_t, copy=False)) File ~\anaconda3\lib\site-packages\numpy\linalg\linalg.py:89, in _raise_linalgerror_singular(err, flag) 88 def _raise_linalgerror_singular(err, flag): ---> 89 raise LinAlgError("Singular matrix") LinAlgError: Singular matrix
arr = np.random.randn(9).reshape(3, 3)
arr
array([[ 0.49195809, 0.10653615, 0.26540123],
[-0.80789976, -1.12249299, -0.13511416],
[-1.29134445, 0.61970383, -0.33890938]])
np.linalg.det(arr)
-0.29981854353410736
np.linalg.inv(arr)
array([[-1.54811692, -0.66899216, -0.94562689],
[ 0.33128668, -0.58700569, 0.49345542],
[ 6.50454654, 1.47570316, 1.55477035]])
vec = np.array([1, 2, 3])
arr = np.diag(vec)
arr
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
np.diag(arr)
array([1, 2, 3])
np.trace(arr)
6
np.linalg.eig(arr)
(array([1., 2., 3.]),
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]]))
eig_values, eig_vectors = np.linalg.eig(arr)
eig_values
array([1., 2., 3.])
eig_vectors
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
# arrays comparisonsarr1 = np.array([1, 2, 3])
arr1 = np.array([1, 2.00000001, 3])
arr2 = np.array([1, 2, 3])
np.allclose(arr1, arr2)
True
# Element-wise Comparison
arr1 == arr2
array([ True, True, True])
A = np.array([[1, 1], [1.5, 4]])
b = np.array([2200, 5050])
np.linalg.inv(A) @ b
array([1500., 700.])
np.linalg.solve(A, b)
array([1500., 700.])
arr = np.array(np.arange(6))
arr
array([0, 1, 2, 3, 4, 5])
np.tile(arr, 3)
array([0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5])
np.repeat(arr, 3)
array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5])
np.tile(arr, (3, 2))
array([[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5],
[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]])
arr = np.genfromtxt("simple_dataset_to_read.csv", delimiter='|')
arr
array([[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.],
[ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10., 11.],
[ 2., 3., 4., 5., 6., 7., 8., 9., 10., 11., 12.],
[ 3., 4., 5., 6., 7., 8., 9., 10., 11., 12., 13.],
[ 4., 5., 6., 7., 8., 9., 10., 11., 12., 13., 14.],
[ 5., 6., 7., 8., 9., 10., 11., 12., 13., 14., 15.],
[ 6., 7., 8., 9., 10., 11., 12., 13., 14., 15., 16.],
[ 7., 8., 9., 10., 11., 12., 13., 14., 15., 16., 17.],
[ 8., 9., 10., 11., 12., 13., 14., 15., 16., 17., 18.],
[ 9., 10., 11., 12., 13., 14., 15., 16., 17., 18., 19.],
[10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20.]])
new_arr = arr / 50
new_arr
array([[0. , 0.02, 0.04, 0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 ],
[0.02, 0.04, 0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22],
[0.04, 0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24],
[0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26],
[0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28],
[0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 ],
[0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32],
[0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34],
[0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34, 0.36],
[0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34, 0.36, 0.38],
[0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34, 0.36, 0.38, 0.4 ]])
np.savetxt('test_save.csv', new_arr, delimiter=',', fmt='%0.2e')
new_arr
array([[0. , 0.02, 0.04, 0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 ],
[0.02, 0.04, 0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22],
[0.04, 0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24],
[0.06, 0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26],
[0.08, 0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28],
[0.1 , 0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 ],
[0.12, 0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32],
[0.14, 0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34],
[0.16, 0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34, 0.36],
[0.18, 0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34, 0.36, 0.38],
[0.2 , 0.22, 0.24, 0.26, 0.28, 0.3 , 0.32, 0.34, 0.36, 0.38, 0.4 ]])
arr = np.ones((10, 5))
arr
array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
new_arr = np.insert(arr, 0, 50, axis=0)
new_arr
array([[50., 50., 50., 50., 50.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
new_arr
array([[50., 50., 50., 50., 50.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
np.delete(new_arr, 0, axis=0)
array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
new_arr[1:]
array([[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.],
[1., 1., 1., 1., 1.]])
# Creating input array
A = np.array([[1, 2, -3], [2, -5, 4], [5, 4, -1]])
# Solution Array
b = np.array([[-3], [13], [5]])
from scipy import linalg
# Solve the linear algebra
x = linalg.solve(A, b)
x
array([[ 2.],
[-1.],
[ 1.]])
A.dot(x) - b
array([[0.],
[0.],
[0.]])
values, vectors = linalg.eig(A)
# # Sparse Matrix
# [
# [0, 0, 1, 0, 0, 0, 0]
# [1, 0, 1, 0, 0, 0, 0]
# [0, 0, 1, 0, 0, 0, 0]
# ]
Broadcasting in NumPy follows a strict set of rules to determine the interaction between the two arrays:
Let's look at adding a two-dimensional array to a one-dimensional array:
(1, 5) + (2, 5)
a = np.array([1, 2, 3, 4, 5]) # (5,)
b = np.array([[0, 0, 0, 0, 0], [5, 5, 5, 5, 5]]) # (2, 5)
print(a.shape)
print(b.shape)
a + b
(5,) (2, 5)
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10]])
a = np.array([[1, 2, 3, 4, 5]]) # (1, 5)
b = np.array([[0, 0, 0, 0, 0], [5, 5, 5, 5, 5]]) # (2, 5)
print(a.shape)
print(b.shape)
a + b
(1, 5) (2, 5)
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10]])
# BE CAREFULL
a = np.array([[1], [2], [3], [4], [5]]) # (5, 1)
b = np.array([[0, 0, 0, 0, 0], [5, 5, 5, 5, 5]]) # (2, 5)
print(a.shape)
print(b.shape)
a + b
(5, 1) (2, 5)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Cell In[936], line 8 5 print(a.shape) 6 print(b.shape) ----> 8 a + b ValueError: operands could not be broadcast together with shapes (5,1) (2,5)
# BE CAREFULL
a = np.array([1, 2, 3, 4, 5]) # (5,) --> (1, 5)
b = np.array([[0, 5], [0, 5], [0, 5], [0, 5], [0, 5]]) # (5, 2) --> (5, 2)
print(a.shape)
print(b.shape)
a + b
(5,) (5, 2)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Cell In[937], line 8 5 print(a.shape) 6 print(b.shape) ----> 8 a + b ValueError: operands could not be broadcast together with shapes (5,) (5,2)
broadcasting¶(2, 5) + (2, 5)
a = np.array([[1, 2, 3, 4, 5]]) # (1, 5)
b = np.array([[0, 0, 0, 0, 0], [5, 5, 5, 5, 5]]) # (2, 5)
print(a.shape)
print(b.shape)
a + b
(1, 5) (2, 5)
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10]])
(5, 5) + (5, 5)
a = np.array([[1], [2], [3], [4], [5]]) # (5, 1)
b = np.array([[5, 5, 5, 5, 5]]) # (1, 5)
print(a.shape)
print(b.shape)
a + b
(5, 1) (1, 5)
array([[ 6, 6, 6, 6, 6],
[ 7, 7, 7, 7, 7],
[ 8, 8, 8, 8, 8],
[ 9, 9, 9, 9, 9],
[10, 10, 10, 10, 10]])
ERROR
a = np.array([[1, 2, 3, 4, 5]]) # (1, 5)
b = np.array([[0, 0, 0, 0], [5, 5, 5, 5]]) # (2, 4)
print(a.shape)
print(b.shape)
a + b
(1, 5) (2, 4)
--------------------------------------------------------------------------- ValueError Traceback (most recent call last) Cell In[940], line 7 4 print(a.shape) 5 print(b.shape) ----> 7 a + b ValueError: operands could not be broadcast together with shapes (1,5) (2,4)
Exercise: Implement the numpy vectorized version of the L1 loss. You may find the function abs(x) (absolute value of x) useful.
Reminder:
Expected Output:
| L1 | 1.1 |
def L1(yhat, y):
"""
Arguments:
yhat -- vector of size m (predicted labels)
y -- vector of size m (true labels)
Returns:
loss -- the value of the L1 loss function defined above
"""
### START CODE HERE ### (≈ 1 line of code)
loss = None
### END CODE HERE ###
return loss
yhat = np.array([.9, 0.2, 0.1, .4, .9])
y = np.array([1 , 0 , 0 , 1, 1])
l1_loss = L1(yhat,y)
print("L1 = " + str(l1_loss))
L1 = 1.1
Exercise: Implement the numpy vectorized version of the L2 loss. There are several way of implementing the L2 loss but you may find the function np.dot() useful. As a reminder, if $x = [x_1, x_2, ..., x_n]$, then np.dot(x,x) = $\sum_{j=0}^n x_j^{2}$.
Expected Output:
| L2 | 0.43 |
def L2(yhat, y):
"""
Arguments:
yhat -- vector of size m (predicted labels)
y -- vector of size m (true labels)
Returns:
loss -- the value of the L2 loss function defined above
"""
### START CODE HERE ### (≈ 1 line of code)
loss = None
### END CODE HERE ###
return loss
yhat = np.array([.9, 0.2, 0.1, .4, .9])
y = np.array([1 , 0 , 0 , 1, 1])
l2_loss = L2(yhat,y)
print("L2 = " + str(l2_loss))
L2 = 0.43
dot product using parallelism in python vs numpy_dot_product vs using the for_loop and compute the time needed for each.¶